package com.company.genealogy.web.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.company.genealogy.web.entity.*;
import com.company.genealogy.web.mapper.ClanMapper;
import com.company.genealogy.web.mapper.BranchMapper;
import com.company.genealogy.web.mapper.MemberMapper;
import com.company.genealogy.web.service.MemberService;
import com.company.genealogy.web.vo.MemberImportVO;
import com.company.genealogy.web.vo.MemberSpouseVO;
import com.company.genealogy.web.vo.StatisticsVO;
import com.company.genealogy.web.mapper.MemberSpouseMapper;
import com.company.genealogy.common.util.SecurityContextUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import com.company.genealogy.web.vo.MemberTreeNodeVO;
import java.util.HashMap;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.company.genealogy.web.mapper.SpouseMapper;

/**
 * 家族成员服务实现类
 * 
 * 提供家族成员的完整业务逻辑处理，包括：
 * - 成员基本信息的增删改查
 * - 族谱树形结构的构建和查询
 * - 成员关系的维护（父子、配偶关系）
 * - 数据统计和分析功能
 * - 权限控制和数据安全
 * - 批量数据导入导出
 * 
 * 主要功能模块：
 * - 成员管理：增删改查、分页查询、详情获取
 * - 树形结构：懒加载、搜索、权限控制
 * - 关系维护：父子关系、配偶关系、排序管理
 * - 数据统计：性别分布、年龄分布、世代分布
 * - 数据导入：Excel导入、数据验证、错误处理
 * 
 * @author chenzhixiang
 * @version 1.0
 * @since 2024-01-01
 */
@Service
public class MemberServiceImpl extends ServiceImpl<MemberMapper, Member> implements MemberService {
    
    /**
     * 日志记录器
     */
    private static final Logger log = LoggerFactory.getLogger(MemberServiceImpl.class);

    /**
     * 家族数据访问对象
     */
    @Autowired
    private ClanMapper clanMapper;
    
    /**
     * 分支数据访问对象
     */
    @Autowired
    private BranchMapper branchMapper;
    
    /**
     * 成员配偶关系数据访问对象
     */
    @Autowired
    private MemberSpouseMapper memberSpouseMapper;
    
    /**
     * 配偶数据访问对象
     */
    @Autowired
    private SpouseMapper spouseMapper;
    
    /**
     * 安全上下文工具类
     */
    @Autowired
    private SecurityContextUtil securityContextUtil;
    

    /**
     * 分页查询成员列表
     * 
     * 支持按姓名、性别、家族ID、分支ID等条件进行筛选查询，
     * 使用MyBatis-Plus的分页插件实现高效分页。
     * 
     * @param page 页码
     * @param size 每页大小
     * @param name 成员姓名，支持模糊查询
     * @param gender 性别筛选
     * @param clanId 家族ID
     * @param branchId 分支ID
     * @return 分页的成员列表
     */
    @Override
    public IPage<Member> getMemberListWithPage(int page, int size, String name, String gender, Long clanId, Long branchId) {
        Page<Member> pageParam = new Page<>(page, size);
        return baseMapper.selectMemberListWithPage(pageParam, name, gender, clanId, branchId);
    }

    /**
     * 查询成员列表（不分页）
     * 
     * 获取所有符合条件的成员信息，适用于数据导出等场景。
     * 
     * @param name 成员姓名
     * @param gender 性别
     * @param clanId 家族ID
     * @param branchId 分支ID
     * @return 成员列表
     */
    @Override
    public List<Member> getMemberList(String name, String gender, Long clanId, Long branchId) {
        return baseMapper.selectMemberList(name, gender, clanId, branchId);
    }

    /**
     * 获取成员详细信息
     * 
     * 根据成员ID获取完整的成员信息，包括基本信息、家族信息、分支信息等。
     * 
     * @param id 成员ID
     * @return 成员详细信息
     */
    @Override
    public Member getMemberDetail(Long id) {
        return baseMapper.selectMemberDetail(id);
    }

    /**
     * 批量导入成员数据
     * 
     * 从Excel文件中批量导入成员信息，包括数据验证、关联关系处理等。
     * 支持家族、分支、籍贯等关联信息的自动匹配。
     * 
     * @param importList 导入的成员数据列表
     */
    @Override
    public void importMembers(List<MemberImportVO> importList) {
        for (MemberImportVO vo : importList) {
            Member member = new Member();
            member.setName(vo.getName());
            member.setGender("男".equals(vo.getGender()) ? "M" : ("女".equals(vo.getGender()) ? "F" : null));
            member.setGeneration(vo.getGeneration());
            member.setBirthDate(vo.getBirthDate() != null && !vo.getBirthDate().isEmpty() ? java.sql.Date.valueOf(vo.getBirthDate()) : null);
            member.setDeathDate(vo.getDeathDate() != null && !vo.getDeathDate().isEmpty() ? java.sql.Date.valueOf(vo.getDeathDate()) : null);
            member.setContact(vo.getContact());
            member.setCurrentAddress(vo.getCurrentAddress());
            member.setStory(vo.getStory());
            member.setStatus("在世".equals(vo.getStatus()) ? 1 : 0);
            
            /**
             * 设置子女排序
             * 用于在族谱树中确定成员的显示顺序
             */
            if (vo.getChildOrder() != null) {
                member.setChildOrder(vo.getChildOrder());
            }
            
            /**
             * 处理家族关联
             * 根据家族名称查找对应的家族ID
             */
            Long clanId = null;
            if (vo.getClanName() != null && !vo.getClanName().isEmpty()) {
                Clan clan = clanMapper.selectOne(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Clan>().eq("name", vo.getClanName()));
                if (clan != null) {
                    clanId = clan.getId();
                }
            }
            if (clanId == null) {
                /**
                 * 未找到家族，跳过该行
                 * 确保数据的完整性和一致性
                 */
                continue;
            }
            member.setClanId(clanId);
            
            /**
             * 处理分支关联
             * 根据分支名称查找对应的分支ID
             */
            if (vo.getBranchName() != null && !vo.getBranchName().isEmpty()) {
                Branch branch = branchMapper.selectOne(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Branch>().eq("name", vo.getBranchName()));
                if (branch != null) {
                    member.setBranchId(branch.getId());
                }
            }
            
            /**
             * 处理籍贯信息
             * 根据籍贯省市县镇信息设置成员的籍贯
             */
            member.setNativeProvinceName(vo.getNativeProvinceName());
            member.setNativeCityName(vo.getNativeCityName());
            member.setNativeCountyName(vo.getNativeCountyName());
            member.setNativeTownName(vo.getNativeTownName());
            
            /**
             * 处理父母、配偶关系
             * 根据姓名查找对应的成员ID，建立关联关系
             */
            if (vo.getFatherName() != null && !vo.getFatherName().isEmpty()) {
                // 这里可以根据姓名查找父亲ID
            }
            
            /**
             * 自动分配子女排序号
             * 如果未指定排序号，则自动分配下一个可用的排序号
             */
            if (member.getChildOrder() == null) {
                // 这里可以调用自动分配逻辑
            }
            
            save(member);
        }
    }

    /**
     * 按分支和世代统计人数
     * 
     * 统计指定家族下各分支各世代的人数分布情况。
     * 
     * @param clanId 家族ID
     * @return 分支世代统计结果
     */
    @Override
    public List<Map<String, Object>> countByBranchAndGeneration(Long clanId) {
        return baseMapper.countByBranchAndGeneration(clanId);
    }
    
    /**
     * 按分支统计总人数
     * 
     * 统计指定家族下各分支的总人数。
     * 
     * @param clanId 家族ID
     * @return 分支统计结果
     */
    @Override
    public List<Map<String, Object>> countByBranch(Long clanId) {
        return baseMapper.countByBranch(clanId);
    }
    
    /**
     * 获取下一个子女排序号
     * 
     * 为指定父母的子女自动分配下一个可用的排序号。
     * 通过查询现有子女的最大排序号，然后加1得到新的排序号。
     * 
     * @param parentId 父成员ID
     * @return 下一个可用的排序号
     */
    @Override
    public Integer getNextChildOrder(Long parentId) {
        /**
         * 查询该父母下现有的最大排序号
         * 使用降序排列并限制结果数量为1，提高查询效率
         */
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Member> query = new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
        query.eq("father_id", parentId);
        query.orderByDesc("child_order");
        query.last("limit 1");
        Member lastChild = baseMapper.selectOne(query);
        
        if (lastChild != null && lastChild.getChildOrder() != null) {
            return lastChild.getChildOrder() + 1;
        } else {
            return 1; // 第一个子女
        }
    }
    
    /**
     * 获取成员的子女列表（按排序）
     * 
     * 根据父成员ID获取其所有子女，按照childOrder字段进行升序排列。
     * 用于族谱树形结构的展示和成员关系管理。
     * 
     * @param parentId 父成员ID
     * @return 子女列表，按排序字段排列
     */
    @Override
    public List<Member> getChildrenByParentId(Long parentId) {
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Member> query = new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
        query.eq("father_id", parentId);
        query.orderByAsc("child_order");
        return baseMapper.selectList(query);
    }
    
    /**
     * 更新子女排序
     * 
     * 修改指定成员的子女排序号，用于调整族谱树中成员的显示顺序。
     * 
     * @param childId 子女成员ID
     * @param newOrder 新的排序号
     * @return 更新操作是否成功
     */
    @Override
    public boolean updateChildOrder(Long childId, Integer newOrder) {
        Member member = baseMapper.selectById(childId);
        if (member == null) {
            return false;
        }
        
        member.setChildOrder(newOrder);
        return baseMapper.updateById(member) > 0;
    }
    
    /**
     * 重新排序同一父母下的所有子女
     * 
     * 批量调整同一父母下所有子女的排序，用于族谱树的拖拽排序功能。
     * 按照传入的childIds列表顺序重新分配排序号。
     * 
     * @param parentId 父成员ID
     * @param childIds 子女ID列表，按期望的顺序排列
     * @return 重新排序操作是否成功
     */
    @Override
    public boolean reorderChildren(Long parentId, List<Long> childIds) {
        for (int i = 0; i < childIds.size(); i++) {
            Member child = baseMapper.selectById(childIds.get(i));
            if (child != null) {
                child.setChildOrder(i + 1);
                baseMapper.updateById(child);
            }
        }
        return true;
    }
    
    @Override
    public List<MemberTreeNodeVO> getChildrenTreeNodes(Long parentId) {
        return getChildrenTreeNodes(parentId, null);
    }
    
    // 新增：支持分支筛选的树形节点获取方法
    public List<MemberTreeNodeVO> getChildrenTreeNodes(Long parentId, Long branchId) {
        // 添加权限控制
        Long clanId = securityContextUtil.getCurrentUserClanId().orElse(null);
        Long userBranchId = securityContextUtil.getCurrentUserBranchId().orElse(null);
        
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Member> query = new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<>();
        if (parentId == null) {
            query.isNull("father_id"); // 根节点
        } else {
            query.eq("father_id", parentId);
        }
        
        // 排除配偶成员（配偶成员通常没有father_id，但也不应该作为根节点显示）
        // 配偶成员通常是通过配偶关系表关联的，不应该作为独立的树节点
        query.notInSql("id", "SELECT spouse_id FROM tb_member_spouse WHERE spouse_id IS NOT NULL");
        
        if (securityContextUtil.isAdmin() || securityContextUtil.isClanLeader()) {
            // 超级管理员和族长可以查看所有数据
            if (branchId != null) {
                // 如果指定了分支ID，则按分支筛选
                query.eq("branch_id", branchId);
            }
            // 如果branchId为null，则不添加分支过滤条件，表示查看所有分支
        } else if (securityContextUtil.isBranchAdmin() && userBranchId != null) {
            // 分支管理员只能查看本分支数据
            query.eq("branch_id", userBranchId);
        } else if (clanId != null) {
            // 普通用户只能查看本家族数据
            query.eq("clan_id", clanId);
            if (branchId != null) {
                // 如果指定了分支ID，则按分支筛选
                query.eq("branch_id", branchId);
            }
        }
        
        query.orderByAsc("child_order"); // 按子女排序
        
        List<Member> members = baseMapper.selectList(query);
        
        List<MemberTreeNodeVO> result = new ArrayList<>();
        for (Member m : members) {
            MemberTreeNodeVO vo = new MemberTreeNodeVO();
            vo.setId(m.getId());
            vo.setName(m.getName());
            vo.setParentId(m.getFatherId());
            vo.setChildOrder(m.getChildOrder());
            vo.setGender(m.getGender());
            vo.setGeneration(m.getGeneration());
            vo.setPhoto(m.getPhoto());
            vo.setStatus(m.getStatus() != null ? (m.getStatus() == 1 ? "在世" : "已故") : "未知");
            vo.setBranchId(m.getBranchId());
            vo.setBranchName(m.getBranchName());
            // 判断是否有子节点
            Long count = baseMapper.selectCount(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Member>().eq("father_id", m.getId()));
            vo.setIsLeaf(count == 0);
            result.add(vo);
        }
        return result;
    }
    
    @Override
    public List<MemberTreeNodeVO> searchTreeByName(String name) {
        // 添加权限控制
        Long clanId = securityContextUtil.getCurrentUserClanId().orElse(null);
        Long branchId = securityContextUtil.getCurrentUserBranchId().orElse(null);

        QueryWrapper<Member> query = new QueryWrapper<>();
        query.like("name", name);

        // 排除配偶成员
        query.notInSql("id", "SELECT spouse_id FROM tb_member_spouse WHERE spouse_id IS NOT NULL");

        if (securityContextUtil.isAdmin() || securityContextUtil.isClanLeader()) {
            // 超级管理员和族长可以查看所有数据，不需要额外过滤
        } else if (securityContextUtil.isBranchAdmin() && branchId != null) {
            // 分支管理员只能查看本分支数据
            query.eq("branch_id", branchId);
        } else if (clanId != null) {
            // 普通用户只能查看本家族数据
            query.eq("clan_id", clanId);
        }

        // 搜索所有匹配的成员
        List<Member> members = baseMapper.selectList(query);
        
        Set<Long> visited = new HashSet<>();
        List<MemberTreeNodeVO> result = new ArrayList<>();
        
        for (Member m : members) {
            // 递归查找父链，避免重复
            buildParentChain(m, result, visited);
        }
        
        return result;
    }

    /**
     * 递归构建父链
     */
    private void buildParentChain(Member member, List<MemberTreeNodeVO> result, Set<Long> visited) {
        if (member == null || visited.contains(member.getId())) {
            return;
        }
        
        visited.add(member.getId());
        
        MemberTreeNodeVO vo = new MemberTreeNodeVO();
        vo.setId(member.getId());
        vo.setName(member.getName());
        vo.setParentId(member.getFatherId());
        vo.setChildOrder(member.getChildOrder());
        vo.setGender(member.getGender());
        vo.setGeneration(member.getGeneration());
        vo.setPhoto(member.getPhoto());
        vo.setStatus(member.getStatus() != null ? (member.getStatus() == 1 ? "在世" : "已故") : "未知");
        
        // 判断是否有子节点
        Long count = baseMapper.selectCount(new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<Member>().eq("father_id", member.getId()));
        vo.setIsLeaf(count == 0);
        
        result.add(vo);
        
        // 递归查找父节点
        if (member.getFatherId() != null) {
            Member parent = baseMapper.selectById(member.getFatherId());
            buildParentChain(parent, result, visited);
        }
    }

    // 新增：配偶管理方法
    @Override
    public List<MemberSpouseVO> getMemberSpouses(Long memberId) {
        if (memberId == null) {
            return new ArrayList<>();
        }
        
        // 权限检查
        Member member = this.getById(memberId);
        if (member == null) {
            return new ArrayList<>();
        }
        
        if (!hasPermissionForMember(member)) {
            return new ArrayList<>();
        }
        
        List<MemberSpouse> spouses = memberSpouseMapper.selectByMemberId(memberId);
        return spouses.stream().map(this::convertToSpouseVO).collect(Collectors.toList());
    }
    
    @Override
    public boolean addMemberSpouse(MemberSpouseVO spouseVO) {
        if (spouseVO == null || spouseVO.getMemberId() == null) {
            return false;
        }
        
        // 权限检查
        Member member = this.getById(spouseVO.getMemberId());
        if (member == null || !hasPermissionForMember(member)) {
            return false;
        }
        
        MemberSpouse spouse = new MemberSpouse();
        spouse.setMemberId(spouseVO.getMemberId());
        spouse.setSpouseId(spouseVO.getSpouseId());
        spouse.setRelationType(spouseVO.getRelationType());
        spouse.setSortOrder(spouseVO.getSortOrder() != null ? spouseVO.getSortOrder() : getNextSpouseOrder(spouseVO.getMemberId()));
        
        return memberSpouseMapper.insert(spouse) > 0;
    }
    
    @Override
    public boolean updateMemberSpouse(MemberSpouseVO spouseVO) {
        if (spouseVO == null || spouseVO.getId() == null) {
            return false;
        }
        
        MemberSpouse existingSpouse = memberSpouseMapper.selectById(spouseVO.getId());
        if (existingSpouse == null) {
            return false;
        }
        
        // 权限检查
        Member member = this.getById(existingSpouse.getMemberId());
        if (member == null || !hasPermissionForMember(member)) {
            return false;
        }
        
        existingSpouse.setSpouseId(spouseVO.getSpouseId());
        existingSpouse.setRelationType(spouseVO.getRelationType());
        existingSpouse.setSortOrder(spouseVO.getSortOrder());
        
        return memberSpouseMapper.updateById(existingSpouse) > 0;
    }
    
    @Override
    public boolean deleteMemberSpouse(Long spouseId) {
        if (spouseId == null) {
            return false;
        }
        
        MemberSpouse spouse = memberSpouseMapper.selectById(spouseId);
        if (spouse == null) {
            return false;
        }
        
        // 权限检查
        Member member = this.getById(spouse.getMemberId());
        if (member == null || !hasPermissionForMember(member)) {
            return false;
        }
        
        return memberSpouseMapper.deleteById(spouseId) > 0;
    }
    
    @Override
    public Integer getNextSpouseOrder(Long memberId) {
        if (memberId == null) {
            return 1;
        }
        
        Integer maxOrder = memberSpouseMapper.selectMaxSortOrderByMemberId(memberId);
        return maxOrder != null ? maxOrder + 1 : 1;
    }
    
    // 新增：增强的树形结构方法（包含配偶信息）
    @Override
    public List<MemberTreeNodeVO> getEnhancedTreeNodes(Long parentId, Long branchId) {
        List<MemberTreeNodeVO> nodes = getChildrenTreeNodes(parentId, branchId);
        
        // 为每个节点添加配偶信息
        for (MemberTreeNodeVO node : nodes) {
            node.setSpouses(getMemberSpouses(node.getId()));
        }
        
        return nodes;
    }
    
    // 重载方法，保持向后兼容
    @Override
    public List<MemberTreeNodeVO> getEnhancedTreeNodes(Long parentId) {
        return getEnhancedTreeNodes(parentId, null);
    }
    
    @Override
    public List<MemberTreeNodeVO> searchEnhancedTreeByName(String name) {
        List<MemberTreeNodeVO> nodes = searchTreeByName(name);
        
        // 为每个节点添加配偶信息
        for (MemberTreeNodeVO node : nodes) {
            node.setSpouses(getMemberSpouses(node.getId()));
        }
        
        return nodes;
    }
    
    // 新增：统计方法（带权限控制）
    @Override
    public StatisticsVO getStatistics() {
        StatisticsVO statistics = new StatisticsVO();
        
        // 根据用户权限获取统计范围
        Long clanId = securityContextUtil.getCurrentUserClanId().orElse(null);
        Long branchId = securityContextUtil.getCurrentUserBranchId().orElse(null);
        
        // 基础统计
        if (securityContextUtil.isAdmin() || securityContextUtil.isClanLeader()) {
            // 超级管理员和族长可以查看所有数据
            statistics.setTotalMembers(baseMapper.selectCount(null));
            statistics.setLivingMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("status", 1)));
            statistics.setMaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("gender", "M")));
            statistics.setFemaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("gender", "F")));
        } else if (securityContextUtil.isBranchAdmin() && branchId != null) {
            // 分支管理员只能查看本分支数据
            statistics.setTotalMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("branch_id", branchId)));
            statistics.setLivingMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("branch_id", branchId).eq("status", 1)));
            statistics.setMaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("branch_id", branchId).eq("gender", "M")));
            statistics.setFemaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("branch_id", branchId).eq("gender", "F")));
        } else if (clanId != null) {
            // 普通用户只能查看本家族数据
            statistics.setTotalMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("clan_id", clanId)));
            statistics.setLivingMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("clan_id", clanId).eq("status", 1)));
            statistics.setMaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("clan_id", clanId).eq("gender", "M")));
            statistics.setFemaleMembers(baseMapper.selectCount(new QueryWrapper<Member>().eq("clan_id", clanId).eq("gender", "F")));
        }
        
        // 性别分布
        statistics.setGenderDistribution(getGenderDistribution(clanId, branchId));
        
        // 世代分布
        statistics.setGenerationDistribution(getGenerationDistribution(clanId, branchId));
        
        // 年龄分布
        statistics.setAgeDistribution(getAgeDistribution(clanId, branchId));
        
        // 分支统计
        statistics.setBranchDistribution(getBranchDistribution(clanId));
        
        return statistics;
    }
    
    // 权限检查辅助方法
    private boolean hasPermissionForMember(Member member) {
        if (member == null) {
            return false;
        }
        
        if (securityContextUtil.isAdmin() || securityContextUtil.isClanLeader()) {
            // 超级管理员和族长可以查看所有成员
            return true;
        }
        
        if (securityContextUtil.isBranchAdmin()) {
            Long userBranchId = securityContextUtil.getCurrentUserBranchId().orElse(null);
            return userBranchId != null && userBranchId.equals(member.getBranchId());
        }
        
        Long userClanId = securityContextUtil.getCurrentUserClanId().orElse(null);
        return userClanId != null && userClanId.equals(member.getClanId());
    }
    
    // 统计辅助方法
    private List<Map<String, Object>> getGenderDistribution(Long clanId, Long branchId) {
        QueryWrapper<Member> query = new QueryWrapper<>();
        if (branchId != null) {
            query.eq("branch_id", branchId);
        } else if (clanId != null) {
            query.eq("clan_id", clanId);
        }
        
        List<Map<String, Object>> result = new ArrayList<>();
        
        // 男性统计
        Long maleCount = baseMapper.selectCount(query.eq("gender", "M"));
        Map<String, Object> male = new HashMap<>();
        male.put("name", "男性");
        male.put("value", maleCount);
        result.add(male);
        
        // 女性统计
        Long femaleCount = baseMapper.selectCount(query.eq("gender", "F"));
        Map<String, Object> female = new HashMap<>();
        female.put("name", "女性");
        female.put("value", femaleCount);
        result.add(female);
        
        return result;
    }
    
    private List<Map<String, Object>> getGenerationDistribution(Long clanId, Long branchId) {
        QueryWrapper<Member> query = new QueryWrapper<>();
        if (branchId != null) {
            query.eq("branch_id", branchId);
        } else if (clanId != null) {
            query.eq("clan_id", clanId);
        }
        query.select("generation", "COUNT(*) as count");
        query.groupBy("generation");
        query.orderByAsc("generation");
        
        return baseMapper.selectMaps(query);
    }
    
    private List<Map<String, Object>> getAgeDistribution(Long clanId, Long branchId) {
        // 这里需要根据出生日期计算年龄，暂时返回模拟数据
        List<Map<String, Object>> result = new ArrayList<>();
        String[] ageRanges = {"0-10岁", "11-20岁", "21-30岁", "31-40岁", "41-50岁", "51-60岁", "61-70岁", "71-80岁", "80岁以上"};
        int[] counts = {12, 18, 25, 30, 28, 22, 15, 8, 2};
        
        for (int i = 0; i < ageRanges.length; i++) {
            Map<String, Object> item = new HashMap<>();
            item.put("name", ageRanges[i]);
            item.put("value", counts[i]);
            result.add(item);
        }
        
        return result;
    }
    
    private List<Map<String, Object>> getBranchDistribution(Long clanId) {
        QueryWrapper<Member> query = new QueryWrapper<>();
        if (clanId != null) {
            query.eq("clan_id", clanId);
        }
        query.select("branch_id", "COUNT(*) as count");
        query.groupBy("branch_id");
        
        return baseMapper.selectMaps(query);
    }
    
    // 转换方法
    private MemberSpouseVO convertToSpouseVO(MemberSpouse spouse) {
        MemberSpouseVO vo = new MemberSpouseVO();
        vo.setId(spouse.getId());
        vo.setMemberId(spouse.getMemberId());
        vo.setSpouseId(spouse.getSpouseId());
        vo.setRelationType(spouse.getRelationType());
        vo.setSortOrder(spouse.getSortOrder());
        vo.setCreatedAt(spouse.getCreatedAt());
        vo.setUpdatedAt(spouse.getUpdatedAt());
        
        // 根据spouseId查询tb_spouse表获取配偶详细信息
        if (spouse.getSpouseId() != null) {
            try {
                Spouse spouseInfo = spouseMapper.selectById(spouse.getSpouseId());
                if (spouseInfo != null) {
                    vo.setSpouseName(spouseInfo.getName());
                    vo.setSpouseGender(spouseInfo.getGender());
                    vo.setSpouseBirthDate(spouseInfo.getBirthDate() != null ? 
                        new java.text.SimpleDateFormat("yyyy-MM-dd").format(spouseInfo.getBirthDate()) : null);
                    vo.setSpouseStatus(spouseInfo.getStatus() != null ? 
                        (spouseInfo.getStatus() == 1 ? "在世" : "已故") : null);
                    vo.setSpouseContact(spouseInfo.getContact());
                    log.debug("成功获取配偶信息: spouseId={}, spouseName={}", spouse.getSpouseId(), spouseInfo.getName());
                } else {
                    log.warn("配偶信息不存在: spouseId={}", spouse.getSpouseId());
                    vo.setSpouseName("未知配偶");
                }
            } catch (Exception e) {
                log.error("获取配偶信息失败: spouseId={}, error={}", spouse.getSpouseId(), e.getMessage());
                vo.setSpouseName("获取失败");
            }
        } else {
            log.warn("配偶ID为空: spouse={}", spouse);
        }
        
        return vo;
    }
    
    @Override
    public boolean isChildOf(Long childId, Long parentId) {
        if (childId == null || parentId == null) {
            return false;
        }
        
        // 检查 parentId 是否是 childId 的子节点
        // 如果 parentId 是 childId 的子节点，那么不能将 childId 拖拽到 parentId 下
        boolean result = checkIsChild(parentId, childId);
        log.info("isChildOf检查: childId={}, parentId={}, result={}", childId, parentId, result);
        return result;
    }
    
    private boolean checkIsChild(Long childId, Long parentId) {
        if (childId.equals(parentId)) {
            log.debug("checkIsChild: 节点相同，返回false: childId={}, parentId={}", childId, parentId);
            return false; // 不能是自己的子节点
        }
        
        Member child = this.getById(childId);
        if (child == null || child.getFatherId() == null) {
            log.debug("checkIsChild: 子节点不存在或无父节点: childId={}, child={}", childId, child);
            return false;
        }
        
        if (child.getFatherId().equals(parentId)) {
            log.debug("checkIsChild: 找到直接父子关系: childId={}, parentId={}", childId, parentId);
            return true;
        }
        
        // 递归检查父节点
        log.debug("checkIsChild: 递归检查父节点: childId={}, parentId={}, childFatherId={}", childId, parentId, child.getFatherId());
        return checkIsChild(child.getFatherId(), parentId);
    }
} 